using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.MSTest
{
	
    public partial class ToolkitScriptManagerTests
    {


        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_CombineScripts_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.CombineScripts = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.CombineScripts);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.CombineScripts = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.CombineScripts);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_AllowCustomErrorsRedirect_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.AllowCustomErrorsRedirect = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AllowCustomErrorsRedirect);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.AllowCustomErrorsRedirect = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AllowCustomErrorsRedirect);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_AsyncPostBackErrorMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AsyncPostBackErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AsyncPostBackErrorMessage)) || expectedValue == objectUnderTest.AsyncPostBackErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_AsyncPostBackTimeout_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.AsyncPostBackTimeout = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AsyncPostBackTimeout);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.AsyncPostBackTimeout = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AsyncPostBackTimeout);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.AsyncPostBackTimeout = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AsyncPostBackTimeout);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.AsyncPostBackTimeout = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AsyncPostBackTimeout);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.AsyncPostBackTimeout = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AsyncPostBackTimeout);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_ClientNavigateHandler_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientNavigateHandler = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientNavigateHandler)) || expectedValue == objectUnderTest.ClientNavigateHandler);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EmptyPageUrl_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.EmptyPageUrl = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyPageUrl)) || expectedValue == objectUnderTest.EmptyPageUrl);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableCdn_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableCdn = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableCdn);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableCdn = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableCdn);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableHistory_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableHistory = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableHistory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableHistory = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableHistory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnablePageMethods_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnablePageMethods = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnablePageMethods);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnablePageMethods = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnablePageMethods);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnablePartialRendering_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnablePartialRendering = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnablePartialRendering);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnablePartialRendering = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnablePartialRendering);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableScriptGlobalization_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableScriptGlobalization = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableScriptGlobalization);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableScriptGlobalization = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableScriptGlobalization);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableScriptLocalization_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableScriptLocalization = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableScriptLocalization);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableScriptLocalization = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableScriptLocalization);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableSecureHistoryState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableSecureHistoryState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableSecureHistoryState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableSecureHistoryState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableSecureHistoryState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_LoadScriptsBeforeUI_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.LoadScriptsBeforeUI = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.LoadScriptsBeforeUI);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.LoadScriptsBeforeUI = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.LoadScriptsBeforeUI);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_SupportsPartialRendering_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.SupportsPartialRendering = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.SupportsPartialRendering);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.SupportsPartialRendering = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.SupportsPartialRendering);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_Visible_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_ID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableTheming_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_SkinID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_EnableViewState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ToolkitScriptManagerTests_Property_AppRelativeTemplateSourceDirectory_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
    }
}

